// ============================================================================================================================================
    // ============================================================================================================================================
    //
    //
    // DTColorBlend 颜色混合
    //
    //
    // ============================================================================================================================================
    #ifndef UNITY_SHADER_DT_COLORBLEND_UTIL_INCLUDED  
    #define UNITY_SHADER_DT_COLORBLEND_UTIL_INCLUDED
        //==========================================================================================================================================================
        //
        //  Blend PS混合模式
        //  layer0 是下图层
        //  layer1 是上图层
        //
        //==========================================================================================================================================================
            float4 dt_ToInputColor(float4 col)
            {
                #ifdef UNITY_COLORSPACE_GAMMA
                    return col; 
                #else
                    const float INV_GAMMA = 1.0 / 2.2;
                    return pow(col,INV_GAMMA);
                #endif
            }
            float3 dt_ToInputColor3(float3 col)
            {
                #ifdef UNITY_COLORSPACE_GAMMA
                    return col; 
                #else
                    const float INV_GAMMA = 1.0 / 2.2;
                    return pow(col,INV_GAMMA);
                #endif
            }

            //输出结果时,把统一颜色正确输出
            float4 dt_ToOutputColor(float4 color)
            {
                #ifdef UNITY_COLORSPACE_GAMMA
                    return color;
                #else
                    const float GAMMA = 2.2;
                    return pow(color,GAMMA);
                #endif
            }

            float3 dt_ToOutputColor3(float3 color)
            {
                #ifdef UNITY_COLORSPACE_GAMMA
                    return color;
                #else
                    const float GAMMA = 2.2;
                    return pow(color,GAMMA);
                #endif
            }

            // 安全颜色
            float4 DTtex2D(sampler2D tex, float2 uv) 
            {
                return (tex2D(tex, uv));
                // return dt_ToInputColor(tex2D(tex, uv));   
            }
            float4 DTFinalColorOUT(float3 _finalColor, float _finalalpha) 
            {
                // return dt_ToOutputColor(float4(_finalColor, _finalalpha));
                
                return (float4(_finalColor, _finalalpha));
            }



            // 混合公式的只是颜色，但透明会影响颜色的显示，但不能直接预乘，
            // 因为很多计算使用的是颜色本身，预乘会让颜色变暗，所以最后要处理前层的透明度
            float3 DT_PS_ExpotColorBlendResultColor(float3 finalColor, float3 srcColor, float newLayerAlpha) 
            { 
                return finalColor * newLayerAlpha + srcColor * (1.0 - newLayerAlpha); 
            }

            float3 DT_GetGray(float3 layer0)
            {
                return  (layer0.r + layer0.g + layer0.b) / 3.0; // 最终颜色 
            }            
            float3 DT_GetInvert(float3 layer0)
            {
                return abs(1.0 - layer0); // 最终颜色 
            }
        // ==================================================================
        //
        // 普通
        //
        // ==================================================================
            float3 DT_PS_NORMAL(float3 layer0, float3 layer1)
            {  
                return layer1;
            }
        // ==================================================================
        //
        // 变亮
        //
        // ==================================================================          
            float3 DT_PS_LIGHTEN(float3 layer0, float3 layer1) {
                return max(layer0.rgb, layer1.rgb);
            }
        // ==================================================================
        //
        // 变暗
        //
        // ==================================================================           
            float3 DT_PS_DARKEN(float3 layer0, float3 layer1)
            {
                return min(layer0.rgb, layer1.rgb);
            }
        // ==================================================================
        //
        // 正片叠底
        //
        // ==================================================================            
            float3 DT_PS_MULTIPLY(float3 layer0, float3 layer1)
            {
                return layer1 * layer0;
            }
        // ==================================================================
        //
        // 滤色 1 - (1 - a) * (1 - b)
        //
        // ==================================================================
            float3 DT_PS_SCREEN(float3 layer0, float3 layer1)
            {
                return layer0.rgb + layer1.rgb - layer0.rgb * layer1.rgb;
            } 
        // ==================================================================
        //
        // 颜色加深
        //
        // ================================================================== 
            float3 DT_PS_COLOR_BURN(float3 layer0, float3 layer1)
            {
                float3 col = SAFE_COLOR(layer1); //防除0
                return layer0 - (float3(1.0,1.0,1.0) - layer0) * (float3(1.0,1.0,1.0) - layer1) / col;
            }             
        // ==================================================================
        //
        // 颜色减淡
        //
        // ==================================================================
            float3 DT_PS_COLOR_DODGE(float3 layer0, float3 layer1) {
                return min(1.0, layer0.rgb / (float3(1.0,1.0,1.0) - layer1.rgb));
            }
        // ==================================================================
        //
        // 经典颜色减淡
        //
        // ==================================================================
            float3 DT_PS_CLASSIC_COLOR_DODGE(float3 layer0, float3 layer1)
            {
                const float3 a = layer0.rgb;
                const float3 b = layer1.rgb;
                const float3 col = SAFE_COLOR((float3(1.0,1.0,1.0) - a.rgb)); //防除0
                return b.xyz + a.xyz * layer1.xyz / col.xyz;
            } 
        // ==================================================================
        //
        // 线性加深
        //
        // ==================================================================     
            float3 DT_PS_LINEAR_BURN(float3 layer0, float4 layer1) {
                return layer0.rgb + layer1.rgb - float3(1.0,1.0,1.0);
            }
        // ==================================================================
        //
        // 相加 // 线性减淡
        //
        // ==================================================================    
            float3 DT_PS_ADD(float3 layer0, float3 layer1) {
                return layer1.rgb + layer0.rgb;
            }
        // ==================================================================
        //
        // 叠加
        //
        // ==================================================================
            float3 DT_PS_OVERLAY(float3 _layer0, float3 _layer1)
            { 
                float3 vblack = 2.0 * _layer0 * _layer1;  
                float3 vlinght = 1.0 -  2.0 * (1.0 - _layer0) * (1.0 - _layer1);   
                float3 resultColor = 1;
                float l = 0.01;float l1 = 0.5 - l;  float l2 = 0.5 + l; 
                resultColor.r = smoothstep(l1, l2, _layer0.r);
                resultColor.g = smoothstep(l1, l2, _layer0.g);
                resultColor.b = smoothstep(l1, l2, _layer0.b); 
                float3 finalColor = lerp(vblack, vlinght, resultColor); 
                // float3 finalColor = vblack * (1.0 - resultColor) + vlinght * resultColor  ; 
                return saturate(finalColor );
 
            }
        // ==================================================================
        //
        // 着色
        //
        // ==================================================================
            float getLuminance(float3 layer0) {
                // 加权系数基于人眼对RGB通道的敏感度
                // return dot(color, float3(0.299, 0.587, 0.114));
                // return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
                float gray = dot(layer0, float3(0.2126, 0.7152, 0.0722));
                return float3(gray, gray, gray);
                
            }
            float3 DT_PS_COLORING(float3 _layer0, float3 _layer1)
            {
                float gray = getLuminance(_layer0); //DT_GetGray
                float tmpmin = smoothstep(0.5, 0.0, gray);
                float3 tmpmax = smoothstep(0.5, 1.0, gray);
                // float m = max(_layer1.b,max(_layer1.r, _layer1.g)) * 2.0;
                float3 finalColor = lerp(gray * (_layer1 * 2.0), gray, (tmpmin + tmpmax )) ;
                return  saturate(finalColor); //_layer1 ;//  
            }
             
        // ==================================================================
        //
        // 单色 LIGHTEN
        //
        // ==================================================================
            
            float3 DT_PS_MONO_LIGHTEN(float3 layer0, float _value) 
            {  
                return lerp(layer0, DT_GetGray(layer0), _value);
            }
        // ==================================================================
        //
        // 单色反相 INVERT
        //
        // ==================================================================
            
            float3 DT_PS_MONO_INVERT(float3 layer0, float _value) {
                return abs(_value - layer0);
            }

        // ==================================================================
        //
        // 单色 通道转透明度
        //
        // ==================================================================
            float DT_PS_MONO_CHANLLEL_TO_ALPHA(float4 _Layer0, int mode) {
                int index = clamp(mode, 0, 4);
                if(index < 4){
                    float4 tmp = _Layer0 * DTOneChannelMask[index];
                    return tmp.r + tmp.g + tmp.b + tmp.a;
                }
                else{
                    float tmp = DT_GetGray(_Layer0.rgb) * _Layer0.a;
                    return tmp;
                }                
            }
        
             
            
            //计算混合
            // float4 GetBlend(float4 layer0,float4 layer1,int colorIndex, int alpIndex)
            // {
            //     #if defined(DT_WEB10_QUALITY)
            //         return saturate(layer0 * layer1);
            //     #endif 
            //     const int colorMode = colorIndex;
            //     const float l1 = colorMode > 0 ? 1 : 0;
            //     layer1 = layer1 * l1;
            //     // const int alphaMode = alpIndex; 
            //     // const float AlphaBlendModeFunc[] =
            //     // {                                 //源 
            //     //     DT_ALPHA_BLANE_NORMAL(layer0.a, layer1.a),  //正常 
            //     //     DT_ALPHA_BLANE_ADD(layer0.a, layer1.a),     //相加
            //     //     DT_ALPHA_BLANE_MULTIPLY(layer0.a, layer1.a),//相乘
            //     //     layer0.a,  
            //     //     layer1.a                                    //目标 
            //     // };                    
            //     const float3 ColorBlendModeFunc[] =
            //     {                    
            //         layer0.rgb,
            //         DT_PS_NORMAL(layer0,layer1), // 正常 1
            //         DT_PS_MULTIPLY(layer0,layer1), //相乘 2
            //         DT_PS_COLOR_BURN(layer0,layer1), //颜色加深 3
            //         DT_PS_LINEAR_BURN(layer0,layer1), //线性加深 4
            //         DT_PS_LIGHTEN(layer0,layer1), //变亮 5
            //         DT_PS_SCREEN(layer0,layer1), //滤色 6
            //         DT_PS_COLOR_DODGE(layer0,layer1), //颜色减淡 7
            //         DT_PS_CLASSIC_COLOR_DODGE(layer0,layer1), //经典颜色减淡 8
            //         DT_PS_ADD(layer0,layer1), //相加 线性减淡 9
            //         DT_PS_OVERLAY(layer0,layer1) //叠加 10
            //     };
            //     float4 f; 
            //     f.a = saturate(layer0.a + layer1.a - layer0.a * layer1.a );//AlphaBlendModeFunc[alphaMode]; //
            //     f.rgb = ColorBlendModeFunc[colorMode]; 

            //     f.rgb = DT_PS_ApplyAlphaBlend(f,layer0,layer1);
                

            //     return saturate(f);
            // }
    
    #endif //UNITY_SHADER_DT_COLORBLEND_UTIL_INCLUDED 